home *** CD-ROM | disk | FTP | other *** search
/ Turnbull China Bikeride / Turnbull China Bikeride - Disc 1.iso / DEMON / RISCOS2 / TCP_131S.ARC / c / session < prev    next >
Text File  |  1994-03-06  |  10KB  |  440 lines
  1. /* Session control */
  2. #include <stdio.h>   
  3. #include <stdlib.h>
  4. #include <string.h>
  5. #include <time.h>
  6. #include "global.h"
  7. #include "config.h"
  8. #include "mbuf.h"
  9. #include "netuser.h"
  10. #include "timer.h"
  11. #include "tcp.h"
  12. #include "ax25.h"
  13. #include "lapb.h"
  14. #include "ftp.h"
  15. #include "telnet.h"
  16. #include "finger.h"
  17. #include "netrom.h"
  18. #include "nr4.h"
  19. #include "session.h"
  20. #include "cmdparse.h"
  21. #include "misc.h"
  22.  
  23. static struct session *sessptr(char *);
  24.  
  25. struct session *sessions;
  26. struct session *current;
  27. char notval[] = "Not a valid control block\n";
  28. char badsess[] = "Invalid session\n";
  29.  
  30. /* Convert a character string containing a decimal session index number 
  31.  * into a pointer. If the arg is NULLCHAR, use the current default session.
  32.  * If the index is out of range or unused, return NULLSESSION.
  33.  */
  34. static struct session *sessptr(char *cp)
  35. {
  36.   register struct session *s;
  37.   unsigned int i;
  38.  
  39.   if(cp == NULLCHAR)
  40.   {
  41.     s = current;
  42.   }
  43.   else
  44.   {
  45.     if ((i = atoi(cp)) >= nsessions)
  46.       return NULLSESSION;
  47.     s = &sessions[i];
  48.   }
  49.   if(s == NULLSESSION || s->type == FREE)
  50.     return NULLSESSION;
  51.  
  52.   return s;
  53. }
  54.  
  55. /* Select and display sessions */
  56. int dosession(int argc, char **argv)
  57. {
  58.   struct session *s;
  59.   extern char *tcpstates[];
  60.   extern char *ax25states[];
  61.  
  62.   if(argc > 1)
  63.   {
  64.     if((current = sessptr(argv[1])) != NULLSESSION)
  65.     {
  66.       go(current);
  67.     }
  68.     else
  69.     {
  70.       cwprintf(NULL, "Session %s not active\r\n", argv[1]);
  71.     }
  72.     return 0;
  73.   }
  74.   cwprintf(NULL, " #       &CB Type   Rcv-Q  State        Remote socket\r\n");
  75.   for(s=sessions; s < &sessions[nsessions];s++)
  76.   {
  77.     switch(s->type)
  78.     {
  79.     case TELNET:
  80.       cwprintf(NULL, "%c%-3d%8lx Telnet  %4d  %-13s%-s:%s\r\n",
  81.       (current == s)? '*':' ',
  82.       (int)(s - sessions),
  83.       (long)s->cb.telnet->tcb,
  84.       s->cb.telnet->tcb->rcvcnt,
  85.       tcpstates[s->cb.telnet->tcb->state],
  86.       s->name,
  87.       tcp_port(s->cb.telnet->tcb->conn.remote.port));
  88.       break;
  89.     case FTP:
  90.       cwprintf(NULL, "%c%-3d%8lx FTP     %4d  %-13s%-s:%s\r\n",
  91.       (current == s)? '*':' ',
  92.       (int)(s - sessions),
  93.       (long)s->cb.ftp->control,
  94.       s->cb.ftp->control->rcvcnt,
  95.       tcpstates[s->cb.ftp->control->state],
  96.       s->name,
  97.       tcp_port(s->cb.ftp->control->conn.remote.port));
  98.       break;
  99.     case AX25TNC:
  100.       cwprintf(NULL, "%c%-3d%8lx AX25    %4d  %-13s%-s\r\n",
  101.       (current == s)? '*':' ',
  102.       (int)(s - sessions),
  103.       (long)s->cb.ax25_cb,
  104.       len_mbuf(s->cb.ax25_cb->rxq),
  105.       ax25states[s->cb.ax25_cb->state],
  106.       s->name);
  107.       break;
  108.     case FINGER:
  109.       cwprintf(NULL, "%c%-3d%8lx Finger  %4d  %-13s%-s:%s\r\n",
  110.       (current == s)? '*':' ',
  111.       (int)(s - sessions),
  112.       (long)s->cb.finger->tcb,
  113.       s->cb.finger->tcb->rcvcnt,
  114.       tcpstates[s->cb.finger->tcb->state],
  115.       s->name,
  116.       tcp_port(s->cb.finger->tcb->conn.remote.port));
  117.       break;
  118.     case NRSESSION:
  119.       cwprintf(NULL, "%c%-3d%8lx NET/ROM %4d  %-13s%-s\r\n",
  120.       (current == s)? '*':' ',
  121.       (int)(s - sessions),
  122.       (long)s->cb.nr4_cb,
  123.       len_mbuf(s->cb.nr4_cb->rxq),
  124.       Nr4states[s->cb.nr4_cb->state],
  125.       s->name);
  126.       break;
  127.     default:
  128.       continue;
  129.     }
  130.     if(s->rfile != NULLCHAR)
  131.       cwprintf(NULL, "        Record: %s\r\n",s->rfile);
  132.     if(s->ufile != NULLCHAR)
  133.       cwprintf(NULL, "        Upload: %s\r\n",s->ufile);
  134.   }
  135.   return 0;
  136. }
  137.  
  138. /* Enter conversational mode with current session */
  139. int go(struct session *active)
  140. {
  141.   if (active == NULL)
  142.     active = current;
  143.     
  144.   if(active == NULLSESSION || active->type == FREE)
  145.     return 0;
  146.  
  147.   mode = CONV_MODE;
  148.   switch(active->type)
  149.   {
  150.   case TELNET:
  151.     cwtitle(active->window, "Telnet - %s", active->name);
  152.     if (active->cb.telnet->remote[TN_ECHO])
  153.     {
  154.       raw();  /* Re-establish raw mode if it was set */
  155.       active->raw = TRUE;
  156.     }
  157.     rcv_char(active->cb.telnet->tcb,0); /* Get any pending input */
  158.     break;
  159.   case FTP:
  160.     cwtitle(active->window, "FTP - %s", active->name);
  161.     ftpccr(active->cb.ftp->control,0);
  162.     break;
  163.   case AX25TNC:
  164.     cwtitle(active->window, "AX25 - %s", active->name);
  165.     ax_rx(active->cb.ax25_cb,0);
  166.     break;
  167.   case FINGER:
  168.     cwtitle(active->window, "Finger - %s", active->name);
  169.     fingcli_rcv(active->cb.finger->tcb, 0) ;
  170.     break ;
  171.   case NRSESSION:
  172.     cwtitle(active->window, "NET/ROM - %s", active->name);
  173.     nr4_rx(active->cb.nr4_cb,0) ;
  174.     break ;
  175.   }
  176.   return 0;
  177. }
  178.  
  179. void close_sess(struct session *s)
  180. {
  181.   switch(s->type)
  182.   {
  183.   case TELNET:
  184.     close_tcp(s->cb.telnet->tcb);
  185.     break;
  186.   case FTP:
  187.     close_tcp(s->cb.ftp->control);
  188.     break;
  189.   case AX25TNC:
  190.     disc_ax25(s->cb.ax25_cb);
  191.     break;
  192.   case FINGER:
  193.     close_tcp(s->cb.finger->tcb);
  194.     break;
  195.   case NRSESSION:
  196.     disc_nr4(s->cb.nr4_cb) ;
  197.     break ;
  198.   }
  199. }
  200.  
  201. int doclose(int argc, char **argv)
  202. {
  203.   struct session *s;
  204.  
  205.   if((s = sessptr(argc > 1 ? argv[1] : NULLCHAR)) == NULLSESSION)
  206.   {
  207.     cwprintf(NULL, badsess);
  208.     return -1;
  209.   }
  210.   close_sess(s);
  211.   return 0;
  212. }
  213. int doreset(int argc, char **argv)
  214. {
  215.   struct session *s;
  216.  
  217.   if((s = sessptr(argc > 1 ? argv[1] : NULLCHAR)) == NULLSESSION){
  218.     cwprintf(NULL, badsess);
  219.     return -1;
  220.   }
  221.   switch(s->type)
  222.   {
  223.   case TELNET:
  224.     reset_tcp(s->cb.telnet->tcb);
  225.     break;
  226.   case FTP:
  227.     if(s->cb.ftp->data != NULLTCB)
  228.     {
  229.       reset_tcp(s->cb.ftp->data);
  230.       s->cb.ftp->data = NULLTCB;
  231.     }
  232.     reset_tcp(s->cb.ftp->control);
  233.     break;
  234.   case AX25TNC:
  235.     reset_ax25(s->cb.ax25_cb);
  236.     break;
  237.   case FINGER:
  238.     reset_tcp(s->cb.finger->tcb);
  239.     break;
  240.   case NRSESSION:
  241.     reset_nr4(s->cb.nr4_cb) ;
  242.     break ;
  243.   }
  244.   return 0;
  245. }
  246.  
  247. int dokick(int argc, char **argv)
  248. {
  249.   struct session *s;
  250.  
  251.   if((s = sessptr(argc > 1 ? argv[1] : NULLCHAR)) == NULLSESSION){
  252.     cwprintf(NULL, badsess);
  253.     return -1;
  254.   }
  255.   switch(s->type)
  256.   {
  257.   case TELNET:
  258.     if(kick_tcp(s->cb.telnet->tcb) == -1)
  259.     {
  260.       cwprintf(NULL, notval);
  261.       return 1;
  262.     }
  263.     break;
  264.   case FTP:
  265.     if(kick_tcp(s->cb.ftp->control) == -1)
  266.     {
  267.       cwprintf(NULL, notval);
  268.       return 1;
  269.     }
  270.     if(s->cb.ftp->data != NULLTCB)
  271.       kick_tcp(s->cb.ftp->data);
  272.     break;
  273.   case AX25TNC:
  274.     if(kick_ax25(s->cb.ax25_cb) == -1){
  275.       cwprintf(NULL, notval);
  276.       return 1;
  277.     }
  278.     return 1;
  279.   case FINGER:
  280.     if(kick_tcp(s->cb.finger->tcb) == -1)
  281.     {
  282.       cwprintf(NULL, notval);
  283.       return 1;
  284.     }
  285.     break;
  286.   case NRSESSION:
  287.     if(kick_nr4(s->cb.nr4_cb) == -1) {
  288.       cwprintf(NULL, notval) ;
  289.       return 1 ;
  290.     }
  291.     break ;
  292.   }
  293.   return 0;
  294. }
  295. struct session *newsession(void)
  296. {
  297.   register int i;
  298.  
  299.   for (i = 0; i < nsessions; i++)
  300.   {
  301.     if (sessions[i].type == FREE)
  302.     {
  303.       return &sessions[i];
  304.     }
  305.   }
  306.  
  307.   return NULLSESSION;
  308. }
  309. void freesession(struct session *s)
  310. {
  311.   if(s == NULLSESSION)
  312.     return;
  313.   if(s->record != NULLFILE)
  314.   {
  315.     fclose(s->record);
  316.     s->record = NULLFILE;
  317.   }
  318.   if(s->rfile != NULLCHAR)
  319.   {
  320.     free(s->rfile);
  321.     s->rfile = NULLCHAR;
  322.   }
  323.   if(s->upload != NULLFILE)
  324.   {
  325.     fclose(s->upload);
  326.     s->upload = NULLFILE;
  327.   }
  328.   if(s->ufile != NULLCHAR)
  329.   {
  330.     free(s->ufile);
  331.     s->ufile = NULLCHAR;
  332.   }
  333.   if(s->name != NULLCHAR)
  334.   {
  335.     free(s->name);
  336.     s->name = NULLCHAR;
  337.   }
  338.   s->type = FREE;
  339. }
  340. /* Control session recording */
  341. int dorecord(int argc, char **argv)
  342. {
  343.   if(current == NULLSESSION)
  344.   {
  345.     cwprintf(NULL, "No current session\r\n");
  346.     return 1;
  347.   }
  348.   if(argc > 1)
  349.   {
  350.     if(current->rfile != NULLCHAR)
  351.     {
  352.       fclose(current->record);
  353.       free(current->rfile);
  354.       current->record = NULLFILE;
  355.       current->rfile = NULLCHAR;
  356.     }
  357.     /* Open new record file, unless file name is "off", which means
  358.                      * disable recording
  359.                      */
  360.     if (strcmp(argv[1], "off") != 0)
  361.     {
  362.       if ((current->record = fopen(argv[1],"a")) == NULLFILE) {
  363.         cwprintf(NULL, "Can't open %s\r\n", argv[1]);
  364.       }
  365.       else
  366.           {
  367.         current->rfile = malloc((unsigned)strlen(argv[1])+1);
  368.         strcpy(current->rfile,argv[1]);
  369.       }
  370.     }
  371.   }
  372.   if(current->rfile != NULLCHAR)
  373.     cwprintf(NULL, "Recording into %s\r\n",current->rfile);
  374.   else
  375.       cwprintf(NULL, "Recording off\r\n");
  376.   return 0;
  377. }
  378. /* Control file transmission */
  379. int doupload(int argc, char **argv)
  380. {
  381.   struct tcb *tcb;
  382.   struct ax25_cb *axp;
  383.   struct nr4cb *cb ;
  384.  
  385.   if(current == NULLSESSION){
  386.     cwprintf(NULL, "No current session\r\n");
  387.     return 1;
  388.   }
  389.   if(argc > 1){
  390.     switch(current->type){
  391.     case TELNET:
  392.       tcb = current->cb.telnet->tcb;
  393.       break;
  394.     case AX25TNC:
  395.       axp = current->cb.ax25_cb;
  396.       break;
  397.     case NRSESSION:
  398.       cb = current->cb.nr4_cb ;
  399.       break ;
  400.     case FTP:
  401.       cwprintf(NULL, "Uploading on FTP control channel not supported\r\n");
  402.       return 1;
  403.     }
  404.     if(strcmp(argv[1],"stop") == 0 && current->upload != NULLFILE){
  405.       /* Abort upload */
  406.       fclose(current->upload);
  407.       current->upload = NULLFILE;
  408.       if(current->ufile != NULLCHAR){
  409.         free(current->ufile);
  410.         current->ufile = NULLCHAR;
  411.       }
  412.     }
  413.     /* Open upload file */
  414.     if((current->upload = fopen(argv[1],"r")) == NULLFILE){
  415.       cwprintf(NULL, "Can't read %s\r\n",argv[1]);
  416.       return 1;
  417.     }
  418.     current->ufile = malloc((unsigned)strlen(argv[1])+1);
  419.     strcpy(current->ufile,argv[1]);
  420.     /* All set, kick transmit upcall to get things rolling */
  421.     switch(current->type){
  422.     case AX25TNC:
  423.       (*axp->t_upcall)(axp,axp->paclen * axp->maxframe);
  424.       break;
  425.     case NRSESSION:
  426.       (*cb->t_upcall)(cb, NR4MAXINFO) ;
  427.       break ;
  428.     case TELNET:
  429.       (*tcb->t_upcall)(tcb,tcb->snd.wnd - tcb->sndcnt);
  430.       break;
  431.     }
  432.   }
  433.   if(current->ufile != NULLCHAR)
  434.     cwprintf(NULL, "Uploading %s\r\n",current->ufile);
  435.   else
  436.       cwprintf(NULL, "Uploading off\r\n");
  437.   return 0;
  438. }
  439.  
  440.